package com.example.superoa.model.service;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.HashSet;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.alibaba.fastjson.JSONArray;
import com.example.superoa.model.dao.PositionDao;
import com.example.superoa.model.dao.QxFunctionDao;
import com.example.superoa.model.dao.StaffDao;
import com.example.superoa.model.mappers.PositionMapper;
import com.example.superoa.model.mappers.QxFunctionMapper;
import com.example.superoa.model.pojos.Position;
import com.example.superoa.model.pojos.QxFunction;
import com.example.superoa.model.pojos.Staff;
import com.example.superoa.model.vo.DeptStaffVo;
import com.example.superoa.model.vo.FunctionVo;
import com.example.superoa.model.vo.RoleFunVo;


//rollbackFor 当方法抛出指定异常时，进行事务回滚
@Transactional(rollbackFor=Exception.class)
@Service
public class PositionService {
	@Autowired
	private PositionDao pdao;
	@Autowired
	private QxFunctionDao qfdao;
	@Autowired
	private PositionMapper pm;
	@Autowired
	private QxFunctionMapper fm;
	@Autowired
	private StaffDao sdao;
	
	public List<Position> findAll(){
		return pm.findAlls();
	}
	//新增+编辑
	public void saveposition(Position position,int Depart_id){
		System.err.println("部门id啊："+Depart_id);
		if(position.getPositionId()!=0) {
			//编辑
			System.err.println("修改："+position.toString());
//			pdao.save(position);jpa的保存方法会删除一切与外表之间的联系
			pm.updaterole(position.getPositionName(), position.getPositionMs(), position.getPositionId());
			pm.updateRoleDeapart(Depart_id, position.getPositionId());
		}else {
			//新增
			Position p=new Position();
			p.setPositionName(position.getPositionName());
			p.setPositionMs(position.getPositionMs());
			pdao.save(p);
			pm.saveRoleDeapart(p.getPositionId(), Depart_id);
		}
		
	}
	//根据角色编号查询信息
	public JSONArray findOne(int positionId){
		return pm.findOne(positionId);
	}
	
	//根据角色编号查询信息
		public JSONArray findStaff(int positionId){
			return pm.findStaff(positionId);
		}
		
	//根据角色编号查询信息
		public JSONArray findStaffAll(){
			return pm.findStaffAll();		
		}
		
	//根据角色编号和用户编号删除记录
		public void deleteStaff(int staffid,int positionid){
				pm.deleteStaff(staffid, positionid);	
		}
	
	//根据员工姓名查询员工是否存在
		public JSONArray findStaffif(String staffname) {
			if(staffname!=null&&staffname!="") {
			return pm.findStaffif(staffname);
			}else {
				return pm.findStaffif("么");
			}
		}
		
		/**
		 * 
		 * @return 部门----一级
		 * 				员工----二级
		 */
		public List<DeptStaffVo> roleTree1() {
			//先查一级分类
			List<DeptStaffVo> dept =  pm.findDept();
			for (DeptStaffVo d : dept) {
				//写一个根据部门ID查询出该部门所有的员工
				List<DeptStaffVo> s=pm.findEmpBydept(d.getId());
				d.setChildren(s);
			}
			return dept;
		}
		
		
	/**
	 * 初始化授权窗口的tree
	 * @return
	 */
	public List<FunctionVo> roleTree(Integer positionId) {
		//先查一级分类
		List<FunctionVo> fun1 = fm.functionRoleList(positionId,0);
		//循环一级，根据一级的编号查询二级
		for (FunctionVo f1 : fun1) {
			//查询二级
			List<FunctionVo> fun2 = fm.functionRoleList(positionId,f1.getId());
			for (FunctionVo f2 : fun2) {
				//查询三级
				List<FunctionVo> fun3 = fm.functionRoleList(positionId,f2.getId());
				//将3级的功能分类添加到一级的children
				f2.setChildren(fun3);
			}	
			//将2级的功能分类添加到一级的children
			f1.setChildren(fun2);
		}
		return fun1;
	}
	
	
	/**
	 * 授权
	 */
	public void saveGrant(List<Integer> ids,int positionId) {
		//先查找角色
				Position p = pdao.findById(positionId).get();

				List<QxFunction> q = p.getQxFunctions();
				if(q==null) {
					q=new ArrayList<>();
				}
				System.err.println(p.getPositionId()+"-----"+ids+"-----"+q.size());
				//一定要清空原表中的数据，否则会主键重复
				q.clear();
				//根据功能编号查找功能对象集合
				List<QxFunction> allFun = (List<QxFunction>) qfdao.findAllById(ids);
				q.addAll(allFun);
	}

	
	/**
	 * 给用户赋予角色
	 */
/*	public void saveRoleStaff(int staff_id,int positionId) {
		//先查找角色
		System.err.println("腰果1号："+staff_id+"腰果2号："+positionId);
				pm.saveRoleStaff(staff_id, positionId);
	}*/
	
	/**
	 * 编辑该角色下的用户
	 */
	public void updateRoleStaff(List<Integer> ids,int positionId) {
		//先查找角色
		Position p = pdao.findById(positionId).get();

		List<Staff> s = p.getStaffs();
		if(s==null) {
			s=new ArrayList<>();
		}
		System.err.println(p.getPositionId()+"-----"+ids+"-----"+s.size());
		//一定要清空原表中的数据，否则会主键重复
		s.clear();
		//根据员工编号查找员工对象集合
		List<Staff> allFun = (List<Staff>) sdao.findAllById(ids);
		s.addAll(allFun);
	}

	/**
	 * 分级查询功能列表
	 * @return
	 */
	public List<RoleFunVo> allFunsByUser() {
		List<RoleFunVo> fun1 = fm.allFunction(0);
		for (RoleFunVo f : fun1) {
			//根据一级查询二级，把二级的集合添加到一级的子集
			List<RoleFunVo> funs = fm.allFunction(f.getFunction_id());
			f.setFuns(funs);
		}
		return fun1;
	}
	
	public Set<Integer> allFunsByUser(int staffId){
		List<Integer> list = fm.allFunctionByUser(staffId);
		Set<Integer> set = new HashSet<>(list);
		return set;
	}
	
	/**
	 * 查询某用户的某个二级功能的所有三级功能
	 * @param userId
	 * @param parentId
	 * @return
	 */
	public JSONArray minFunctionByUser(int staffId,int parentId) {
		return fm.minFunctionByUser(staffId, parentId);
	}
}